package production_controllers

import (
	"beego_gorm_mysql/models/production_models"
	"beego_gorm_mysql/utils"
	"fmt"
	"time"

	"github.com/beego/beego/v2/server/web"
)

type BatchMasterController struct {
	web.Controller
}

// Create 创建新批次
func (c *BatchMasterController) Create() {
	utils.Logger.Println("=== 开始处理创建批次请求 ===")
	// 步骤1: 声明批次变量
	var batch production_models.BatchMaster

	// 步骤2: 解析表单数据
	if err := c.ParseForm(&batch); err != nil {
		fmt.Printf("解析表单失败: %v\n", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "参数解析失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 步骤3: 打印接收到的数据，用于调试
	utils.Logger.Printf("✅ 接收到的数据: batch_no=%s, crop_type=%s, created_by=%s\n",
		batch.BatchNo, batch.CropType, batch.CreatedBy)

	// 步骤4: 数据验证
	if batch.BatchNo == "" || batch.CropType == "" || batch.CreatedBy == "" {
		utils.Logger.Println("❌ 数据验证失败：必填字段为空")
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "批次号、作物类型和创建人不能为空",
		}
		c.ServeJSON()
		return
	}

	// 步骤5: 生成批次ID
	batch.BatchID = fmt.Sprintf("BATCH_%s_%04d",
		time.Now().Format("20060102"),
		time.Now().UnixNano()%10000)
	utils.Logger.Printf("✅ 生成批次ID: %s\n", batch.BatchID)
	// 步骤6: 设置默认值
	batch.Status = 0 // 进行中状态
	batch.CreatedAt = time.Now()
	batch.UpdatedAt = time.Now()

	// 步骤7: 保存到数据库
	if err := utils.DB.Create(&batch).Error; err != nil {
		utils.Logger.Printf("❌ 数据库错误: %v\n", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "创建批次失败: " + err.Error(),
		}
	} else {
		// 步骤8: 返回成功响应
		utils.Logger.Printf("✅ 批次创建成功: ID=%d\n", batch.ID)
		c.Data["json"] = map[string]interface{}{
			"success": true,
			"data":    batch,
		}
	}

	// 步骤9: 发送JSON响应
	c.ServeJSON()
	utils.Logger.Println("=== 批次创建请求处理完成 ===")
}

// Get 获取单个批次详情
// @Summary 根据ID获取批次详情
// @Description 通过批次ID查询并返回批次的完整信息
// @Param id query int true "批次ID"
// @Success 200 {object} map[string]interface{} "包含批次详细信息"
// @Failure 404 {object} map[string]interface{} "批次不存在"
func (c *BatchMasterController) Get() {
	utils.Logger.Println("=== 开始获取批次详情 ===")

	// 从URL参数中获取批次ID
	id, _ := c.GetInt("id")
	var batch production_models.BatchMaster

	// 根据ID查询批次信息
	if err := utils.DB.First(&batch, id).Error; err != nil {
		utils.Logger.Printf("❌ 批次不存在: ID=%d\n", id)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "批次不存在",
		}
	} else {
		utils.Logger.Printf("✅ 获取批次成功: ID=%d\n", id)
		c.Data["json"] = map[string]interface{}{
			"success": true,
			"data":    batch,
		}
	}
	c.ServeJSON()
}

// Update 更新批次信息
// @Summary 更新批次信息
// @Description 根据ID更新批次的基本信息，包括作物类型等
// @Param id query int true "批次ID"
// @Param crop_type formData string false "作物类型"
// @Success 200 {object} map[string]interface{} "更新成功"
// @Failure 404 {object} map[string]interface{} "批次不存在"
// @Failure 400 {object} map[string]interface{} "参数错误"
func (c *BatchMasterController) Update() {
	utils.Logger.Println("=== 开始更新批次信息 ===")

	// 从URL参数中获取批次ID，并检查错误
	id, err := c.GetInt("id")
	if err != nil || id == 0 {
		utils.Logger.Printf("❌ 参数错误: %v\n", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的批次ID",
		}
		c.ServeJSON()
		return
	}

	var batch production_models.BatchMaster

	// 先查找现有批次，确保记录存在
	if err := utils.DB.First(&batch, id).Error; err != nil {
		utils.Logger.Printf("❌ 批次不存在: ID=%d\n", id)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "批次不存在",
		}
		c.ServeJSON()
		return
	}

	// 创建一个临时结构来接收仅允许更新的字段
	type updateFields struct {
		CropType string `form:"crop_type"`
	}
	var updates updateFields

	// 解析并验证需要更新的字段
	if err := c.ParseForm(&updates); err != nil {
		utils.Logger.Printf("❌ 解析表单失败: %v\n", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "参数解析失败",
		}
		c.ServeJSON()
		return
	}

	// 更新指定的字段
	batch.CropType = updates.CropType
	batch.UpdatedAt = time.Now()

	// 保存更新到数据库
	if err := utils.DB.Save(&batch).Error; err != nil {
		utils.Logger.Printf("❌ 更新失败: %v\n", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "更新批次失败",
		}
	} else {
		utils.Logger.Printf("✅ 更新成功: ID=%d\n", id)
		c.Data["json"] = map[string]interface{}{
			"success": true,
			"data":    batch,
		}
	}
	c.ServeJSON()
}

// Delete 删除批次
// @Summary 删除指定批次
// @Description 根据ID删除批次记录（软删除）
// @Param id query int true "批次ID"
// @Success 200 {object} map[string]interface{} "删除成功"
// @Failure 500 {object} map[string]interface{} "删除失败"
func (c *BatchMasterController) Delete() {
	utils.Logger.Println("=== 开始删除批次 ===")

	// 从URL参数中获取批次ID
	id, _ := c.GetInt("id")
	// 执行软删除操作（由于GORM的软删除特性，记录不会真正从数据库中删除）
	if err := utils.DB.Delete(&production_models.BatchMaster{}, id).Error; err != nil {
		utils.Logger.Printf("❌ 删除失败: %v\n", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "删除批次失败",
		}
	} else {
		utils.Logger.Printf("✅ 删除成功: ID=%d\n", id)
		c.Data["json"] = map[string]interface{}{
			"success": true,
		}
	}
	c.ServeJSON()
}

// UpdateStatus 更新批次状态
// @Summary 更新批次状态
// @Description 更新指定批次的状态值
// @Param id query int true "批次ID"
// @Param status query int true "新状态值(0:进行中 1:已完成 2:已取消)"
// @Success 200 {object} map[string]interface{} "更新成功"
// @Failure 404 {object} map[string]interface{} "批次不存在"
// @Failure 500 {object} map[string]interface{} "更新失败"
func (c *BatchMasterController) UpdateStatus() {
	utils.Logger.Println("=== 开始更新批次状态 ===")

	// 从URL参数中获取批次ID和新状态值
	id, _ := c.GetInt("id")
	status, _ := c.GetInt8("status")

	// 使用Model方法更新指定字段
	result := utils.DB.Model(&production_models.BatchMaster{}).
		Where("id = ?", id).
		Updates(map[string]interface{}{
			"status":     status,
			"updated_at": time.Now(),
		})

	// 处理更新结果
	if result.Error != nil {
		utils.Logger.Printf("❌ 状态更新失败: %v\n", result.Error)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "更新状态失败",
		}
	} else if result.RowsAffected == 0 {
		// 如果影响行数为0，说明记录不存在
		utils.Logger.Printf("❌ 批次不存在: ID=%d\n", id)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "批次不存在",
		}
	} else {
		utils.Logger.Printf("✅ 状态更新成功: ID=%d, status=%d\n", id, status)
		c.Data["json"] = map[string]interface{}{
			"success": true,
		}
	}
	c.ServeJSON()
}

func (c *BatchMasterController) List() {
	utils.Logger.Println("=== 开始获取批次列表 ===")

	// 获取查询参数
	cropType := c.GetString("crop_type")
	createdBy := c.GetString("created_by")
	startDate := c.GetString("start_date")
	endDate := c.GetString("end_date")

	utils.Logger.Printf("查询条件: crop_type=%s, created_by=%s, start_date=%s, end_date=%s\n",
		cropType, createdBy, startDate, endDate)

	var batches []production_models.BatchMaster
	query := utils.DB

	// 构建查询条件
	if cropType != "" {
		query = query.Where("crop_type LIKE ?", "%"+cropType+"%")
	}
	if createdBy != "" {
		query = query.Where("created_by LIKE ?", "%"+createdBy+"%")
	}

	// 处理时间查询
	if startDate != "" {
		startTime, err := time.Parse("2006-01-02", startDate)
		if err == nil {
			query = query.Where("created_at >= ?", startTime.Format("2006-01-02 00:00:00"))
		} else {
			utils.Logger.Printf("❌ 开始日期格式错误: %v\n", err)
		}
	}
	if endDate != "" {
		endTime, err := time.Parse("2006-01-02", endDate)
		if err == nil {
			query = query.Where("created_at <= ?", endTime.Format("2006-01-02 23:59:59"))
		} else {
			utils.Logger.Printf("❌ 结束日期格式错误: %v\n", err)
		}
	}

	// 添加排序
	query = query.Order("created_at DESC")

	// 执行查询
	if err := query.Find(&batches).Error; err != nil {
		utils.Logger.Printf("❌ 获取批次列表失败: %v\n", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取批次列表失败",
		}
	} else {
		utils.Logger.Printf("✅ 成功获取批次列表，共 %d 条记录\n", len(batches))
		c.Data["json"] = map[string]interface{}{
			"success": true,
			"data":    batches,
			"total":   len(batches),
		}
	}

	c.ServeJSON()
}
